++++++++++++++++++++
++++++++++++++++++++
++ =-=-=-=-=-=-=- ++
++ = KMICIC^lFE = ++    
++ =-=-=-=-=-=-=- ++
++++++++++++++++++++
++++++++++++++++++++
				


                                PRESENT :



          **************************************************** 
          ****************************************************
          **                                                **
          **   Tutorial do CrackMe v.2.0 by deztroyer^      **
          **                                                **
          ****************************************************
          ****************************************************


SiEmKa! :)

Dzisiaj na przemial idzie drugie crackme deztroyera. Crackme jest typu name-serial, posiada 2 anty-si i jest raczej dla newbe :)

Oki to jedziemy z tym koksem :)

Odpalamy crackme i... nic nie widzimy :) Coz, tu wlasnie znajduje sie pierwsza procka anty-si, ktora musimy ominac aby sobie swobodnie pochasac po kodzie :)

Ladujemy nasze crackme do IDY coby sobie w miare szybko znalezc i ominac nasze anty. Crackme nie jest spakowane takze wszystko ladnie sie nam desassembluje. Jadac powoli po kodziku widzimy takie cos :

 mov     ah, 43h
 int     68h
 cmp     ax, 0F386h
 jz      short loc_40102F  <--- bad boy


Jest to dosc znany trik, ktory mozemy szybciutko usunac. Wystarczy zmienic skok na jakiegos nopa i bedzie git :) Patrzymy na wartosc w hexach tego skoku. Wynosi ona 74 25. Wystarczy teraz otworzyc crackme w dowolnym hexedytorze, wyszukac ta wartosc i zmienic ja na 90 90 czyli na nopy, ktore nic nie robia :) Po tym malym zabiegu crackme juz sie ladnie uruchamia :)

Odpalamy wiec je i wpisujemy jakies dane. Ja wpisalem :

 Kmicic
 123456

Zakladamy pulapke GetDlgItemTextA i naciskamy OK. I coz to? Crackme nam sie zamyka! Hmmm... A wiec pewnie kolejne anty-si. Podpowiem, ze tym razem sprobojmy w Si (softice) zalozyc pulapke na tworzenie pliku czyli

 bpx createfilea

(pulapke zakladamy dopiero po uruchomieniu znowu crackmesa). Gdy nacisniemy OK Si sie wlaczy i widzimy takie cos :

 call    CreateFileA
 cmp     eax, 0FFFFFFFFh
 jnz     short loc_4010C3
 jmp     short loc_401119

Zobaczmy co sie dzieje troszke wyzej naciskajac ctrl i strzalke do gory. Widzimy taki kod :

       		 
 call    sub_4011BE
 push    0
 push    3
 push    0
 push    0
 push    0
 push    0
 push    eax

Zaciekawil mnie ten call na samej gorze. Spojrzmy w IDA co on robi.
A robi on takie cos :

 xor     eax, eax
 xor     ebx, ebx
 mov     eax, offset aT39?	; "&&T&)39?" <<--patrz tu
 mov     bl, [eax]
 cmp     bl, 0
 jz      short loc_4011D6
 xor     bl, 7Ah
 mov     [eax], bl
 inc     eax
 jmp     short loc_4011C7
 sub     eax, 8
 retn

Co tu sie dzieje? Do eax laduja pewne znaczki i kazda literka z tych znaczkow laduje do bl i jest xorowana z 7Ah. Nastepnie wynik trafia z powrotem do eax.

To tu na pewno jest troszke zaszyfrowana nazwa naszego tworzonego pliku! Teraz to odszyfrujmy. To proste. Po prostu bierzemy kolejne znaczki ( &&T&)39? ) i xorujemy je z 7Ah. Kazdy znaczek ma swoj odpowiednik w hexach i np "&" wynosi 26h. Teraz :

26h^7Ah = 92h = \

Czyli pierwsza literka naszego tworzonego pliku to "\". Analogicznie postepujemy z pozostalymi literkami i wychodzi nam takie cos :

 \\.\SICE

Sice?! Przeciez to pieprzony sterownik naszego debugera! :) Czyli nasze kolejne anty-si. Sprawdza czy jest pliczek \\.\SICE (w pamieci) i jesli tak to crackme sie zamyka. Aby sie za bardzo z tym nie cackac proponuje wrocic to tego miejsca w kodzie :

 call    CreateFileA
 cmp     eax, 0FFFFFFFFh
 jnz     short loc_4010C3  <<--bad boy

I zmienic jnz na na nopa :) Czyli widomo :

Ten skok ma wartosc 75 1D. Odszukujemy to w hexedytorze, zamiast tego walimy male nopki i crackme bedzie nam hulac :)

No, to skoro wszystkie anty-si mamy za soba to mozemy sie wreszcie wziasc za glowne algo crackme. A wiec jeszce raz. Pulapeczka na GetDlgItemTextA, swoje dane i jedziemy!

Najpierw ofkoz pobierane jest nasze name :

     CALL      USER32!GetDlgItemTextA
 1.  CMP       EAX,00
     JZ        004010CA
 2.  CMP       EAX,04
     JB        004010E2


1. Jesli brak name to wypad 
2. Jesli name < 4 to tez wypad :)

Dalej juz pobierane jest nasz serial :

     CALL      USER32!GetDlgItemTextA
 1.  CMP       EAX,00
     JZ        004010A8
 2.  CALL      004011DA


1. Jesli nic nie wpisalismy to wypad.
2. Maly call

Wejdzmy zatem do tego calla :

 1.   XOR       EBX,EBX
 2.   MOV       EAX,0040325B
 3.   MOV       BL,[EAX]
      CMP       BL,00
 4.   JZ        004011F5
 5.   CMP       BL,30
      JB        00401200
 6.   CMP       BL,39
      JA        00401200
      INC       EAX
      JMP       004011E1
      MOV       DWORD PTR [004032C7],00000000
      RET

1. Zerowanie ebx
2. Do eax laduje nasz serial
3. Do bl idzie pierwsza (potem kolejne) literka
4. Jak koniec to skok
5. Porownanie z 0 (cyfra)
6. Porownanie z 9 (cyfra)

Ten krotki kodzik sprawdza po prostu czy nasz serial sklada sie z liczb a nie innych znakow. Jesli nie sklada sie z liczb to wypad :)

Dalej po callu mamy :

		 
 1.   CMP       DWORD PTR [004032C7],00
 2.   JNZ       004010A8
 3.   XOR       EBX,EBX
 4.   XOR       ECX,ECX
 5.   MOV       EAX,004031F7
 6.   MOV       BL,[EAX]
 7.   CMP       BL,00
 8.   JZ        0040117E
 9.   XOR       BL,27
 10.  ADD       ECX,EBX
 11.  INC       EAX
 12.  JMP       0040116F
 13.  SHL       ECX,1
 14.  SHL       ECX,1
 15.  MOV       [004032BF],ECX

1. Porownanie odnoszace sie do naszego calla
2. Jesli nie bylo liczb to wypad :)

3. Zerowanie ebx
4. Zerowanie ecx
5. Do eax idzie nasze name
6. Do bl idzie pierwsza literka (potem kolejne) nicka
7. Porownanie czy koniec nicka
8. Jesli koniec nicka to skok
9. xorowanie literki z 27h
10. dodanie wyniku do ecx
11. Zwiekszenie eax
12. Skok do punktu 6
13. Przesuniecie bitow w lewo o 1
14. Kolejne przesuniecie
15. Wynik laduje do [004032BF]

I co tu sie wyrabia? Po prostu kolejne literki naszego nicka sa xorowane z 27h i dodawane do ecx. Ecx jest suma zxorowanych literek naszego nicka. Potem nastepuje jeszcze dwukrotne przesuniecie bitow i wynik laduje do pamieci. 

Ok lecimy dalej. Po paru pushach mamy :

		 
 1.  CALL      USER32!GetDlgItemInt
 2.  XOR       EAX,12345678
     ROL       EAX,05
     XOR       EAX,DEADDEAD
 3.  CMP       EAX,[004032BF]
 4.  JZ        004010FA
 5.  JMP       004010A8
     LEAVE
     RET


1. Pobranie textu (seriala dokladnie)
2. Male mielenie seriala 
3. Porownanie wyniku mielenia z [004032BF] czyli naszym ecx
4. Jesli rowne to gitara
5. Jesli nie to wypad :)

Tu jest wszystko czego nam potrzeba aby rozwalic to crackme na nasz nick :) 

Otoz, jak wiemy nasze ecx jest to po prostu nasz przemielony nick, ktory znajduje sie w [004032BF]. U gory widzimy jak nasz serial jest rowniez w jakis sposob mielony, i jesli po tym mieleniu jest rowny temu co jest w [004032BF] czyli naszemu ecx to crackme jest zlamane :) Spojrzmy jeszce raz na procke u gory :

 XOR       EAX,12345678
 ROL       EAX,05
 XOR       EAX,DEADDEAD

I spojrzmy co jest w naszym ecx. U mnie jest : 768h. Pod [004032BF] wyglada to : 68 07.

Czyli teraz, jesli po tym malym kodzie u gory wyjdzie nam w eax to co mamy w [004032BF] to jest git. 

W takim razie ja proponuje odwrocic powyzsza procke :

 XOR	   EAX, DEADDEAD
 ROR	   EAX, 05
 XOR	   EAX, 12345678

Teraz wystarczy tylko do eax wlozyc nasza wartosc po mieleniu naszego nicka spod [004032BF] i po przejsciu po tej procce podejrzec eax. To co tam bedzie bedzie naszym prawidlowym serialem :)

Czyli dla moich danych robie takie cos :

 MOV	   EAX, 00000768h   <<-- Moje ecx
 XOR	   EAX, DEADDEADh
 ROR	   EAX, 05h
 XOR	   EAX, 12345678h

Po tym wszystkim w decymach wyjdzie : 001019295926d

Zera pomijamy i mam takie oto dane dla mnie :

 Kmicic
 1019295926

No, i to by bylo na tyle w dzisiejszym odcinku :)

Pozdro!
Kmicic